{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-17T05:42:25.404948Z",
     "start_time": "2025-01-17T05:42:23.832846Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取",
   "id": "c9417c9238e28500"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T05:52:59.334120Z",
     "start_time": "2025-01-17T05:52:59.327992Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  #实例化DictVectorizer，把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform，把字典转换成矩阵\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}]) # 字典数据转成稀疏矩阵(3行4列，有北京、上海、深圳和temperature这四个特征；北京、上海、深圳三个特征里：“是”为1，“不是”为0)，再输出不为0的坐标和值\n",
    "    \n",
    "    print(data)\n",
    "    print(data.shape)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out()) # 输出每个特征的名称\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去.inverse_transform()函数可以把矩阵转换成字典数据\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "id": "e993bab5f860f7fb",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "(3, 4)\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 2 一段英文文本如何变为数值类型",
   "id": "5311ef12626ee632"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T06:16:20.225955Z",
     "start_time": "2025-01-17T06:16:20.219465Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2) #实例化CountVectorizer，min_df=2指的是将出现次数大于等于2的词语转换为特征\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short i like python life\",\n",
    "         \"life is too long i dislike python\",\n",
    "         \"life is short\"]) #fit_transform()函数会把文本中的词语转换为特征，并返回一个稀疏矩阵\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out()) #i不被转换为特征，是因为它作为特征时没有意义（单个字母、单个字都会被认为没有含义，所以被过滤掉）\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res)) #输出结果为scipy.sparse.csr.csr_matrix类型，稀疏矩阵\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "id": "ab7bdb3487856bb5",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 一段汉字文本如何数值化，对于汉字不能用空格来分割",
   "id": "27e6c7533fd492b6"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T06:41:02.888791Z",
     "start_time": "2025-01-17T06:41:02.880277Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer() #实例化CountVectorizer\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置和值\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "id": "8020030d2204ba5d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 掌握如何对中文进行分词",
   "id": "af3913cd7fba1a3f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T07:55:32.688766Z",
     "start_time": "2025-01-17T07:55:32.676361Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1)) #输出结果为generator类型，生成器\n",
    "    print(con2) \n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1) #把列表转换成字符串，每个词之间用空格隔开\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3 \n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "    # print([c1, c2, c3])\n",
    "    data = cv.fit_transform([c1, c2, c3]) #将字符串文本转换成特征矩阵\n",
    "    \n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "id": "a31ac656549063a5",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "<generator object Tokenizer.cut at 0x000002851D220460>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 37 stored elements and shape (3, 36)>\n",
      "  Coords\tValues\n",
      "  (0, 6)\t2\n",
      "  (0, 26)\t2\n",
      "  (0, 22)\t2\n",
      "  (0, 12)\t1\n",
      "  (0, 32)\t1\n",
      "  (0, 31)\t1\n",
      "  (0, 14)\t1\n",
      "  (0, 24)\t1\n",
      "  (0, 19)\t1\n",
      "  (0, 27)\t1\n",
      "  (0, 2)\t1\n",
      "  (0, 20)\t1\n",
      "  (1, 18)\t3\n",
      "  (1, 28)\t2\n",
      "  (1, 23)\t1\n",
      "  (1, 7)\t1\n",
      "  (1, 8)\t1\n",
      "  (1, 3)\t1\n",
      "  (1, 9)\t1\n",
      "  (1, 35)\t1\n",
      "  (1, 17)\t1\n",
      "  (1, 34)\t1\n",
      "  (2, 18)\t1\n",
      "  (2, 16)\t1\n",
      "  (2, 11)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 21)\t1\n",
      "  (2, 4)\t4\n",
      "  (2, 25)\t1\n",
      "  (2, 5)\t3\n",
      "  (2, 1)\t1\n",
      "  (2, 29)\t2\n",
      "  (2, 13)\t1\n",
      "  (2, 30)\t1\n",
      "  (2, 10)\t1\n",
      "  (2, 15)\t1\n",
      "  (2, 33)\t1\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# tf-idf(对那些词重要程度高低进行评估，重要的词会被赋予更高的权重，不重要的词会被赋予较低的权重：重要的词是指在不同文档中出现次数较少的词，而不重要的词是指在不同文档中出现次数较多的词。)",
   "id": "2aa94df846161e93"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T08:24:05.138503Z",
     "start_time": "2025-01-17T08:24:05.121016Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，idf(x) = log(n/n(x)),从而出现零分裂，为避免出现零分裂，可以加一平滑：smooth_idf=True，平滑idf权重（防止零分裂）。将公式变为：\n",
    "#\n",
    "# idf(x) = log [ (n+1) / (n(x)+1) ] + 1\n",
    "#\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True) #实例化TfidfVectorizer,smooth_idf=True平滑idf权重（防止零分裂）\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "id": "24a648156dd6a959",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "<generator object Tokenizer.cut at 0x000002851D2205C0>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 2 特征处理，不同的特征拉到到同一个量纲",
   "id": "7c40cd48257db101"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T08:55:01.601690Z",
     "start_time": "2025-01-17T08:55:01.594275Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理（每列特征）\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "id": "b388c9838b52ae38",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T08:55:04.172179Z",
     "start_time": "2025-01-17T08:55:04.161714Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的均匀分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "id": "693605944c8da750",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T08:59:30.902827Z",
     "start_time": "2025-01-17T08:59:30.896267Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "id": "c6d6a360f125816d",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "type(data)",
   "id": "95091dbb04a59097"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 3 缺失值处理",
   "id": "29a0e97348ea61c5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T09:03:04.197426Z",
     "start_time": "2025-01-17T09:03:04.182367Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean') #实例化SimpleImputer,替换Nan值为平均值\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "id": "d2efd0877abab3c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "id": "da590067aeccbb2c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T09:07:41.415057Z",
     "start_time": "2025-01-17T09:07:41.407107Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征(因为方差太小的话，不能很好的区分样本，所以可以删除)\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1) #实例化VarianceThreshold,threshold=0.1表示删除方差小于0.1的特征\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()"
   ],
   "id": "2cee122f3268c66",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T13:38:07.662628Z",
     "start_time": "2025-01-17T13:38:07.652220Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维，保留至少90%的方差（并不是删去某些特征，而是降低特征的维度，意味着特征会变化）\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0))  #每一列的方差\n",
    "    print('-' * 50)\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.9) #实例化PCA,n_components=0.9表示保留至少90%的方差\n",
    "\n",
    "    data = pca.fit_transform(original_value) #进行降维\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_) # 解释的方差比例，每一列的方差占总方差的比例\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum()) # 解释的方差比例之和\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()\n"
   ],
   "id": "cb4fa68cb9697891",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.88888889  4.66666667 13.55555556  8.22222222]\n",
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-3.13587302e-16  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333346\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-17T14:31:15.013126Z",
     "start_time": "2025-01-17T14:31:14.106808Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率，rand是均匀分布\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "id": "5a020b85924e0660",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 23
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
